home *** CD-ROM | disk | FTP | other *** search
/ American Osteopathic Ass…tion Yearbook 2005 & 2006 / American Osteopathic Association Yearbook 2005 & 2006.iso / pc / server / mmserv.exe / sgmllib.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2004-07-21  |  15.1 KB  |  532 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.3)
  3.  
  4. import markupbase
  5. import re
  6. __all__ = [
  7.     'SGMLParser']
  8. interesting = re.compile('[&<]')
  9. incomplete = re.compile('&([a-zA-Z][a-zA-Z0-9]*|#[0-9]*)?|<([a-zA-Z][^<>]*|/([a-zA-Z][^<>]*)?|![^<>]*)?')
  10. entityref = re.compile('&([a-zA-Z][-.a-zA-Z0-9]*)[^a-zA-Z0-9]')
  11. charref = re.compile('&#([0-9]+)[^0-9]')
  12. starttagopen = re.compile('<[>a-zA-Z]')
  13. shorttagopen = re.compile('<[a-zA-Z][-.a-zA-Z0-9]*/')
  14. shorttag = re.compile('<([a-zA-Z][-.a-zA-Z0-9]*)/([^/]*)/')
  15. piclose = re.compile('>')
  16. endbracket = re.compile('[<>]')
  17. tagfind = re.compile('[a-zA-Z][-_.a-zA-Z0-9]*')
  18. attrfind = re.compile('\\s*([a-zA-Z_][-:.a-zA-Z_0-9]*)(\\s*=\\s*(\\\'[^\\\']*\\\'|"[^"]*"|[-a-zA-Z0-9./,:;+*%?!&$\\(\\)_#=~\\\'"@]*))?')
  19.  
  20. class SGMLParseError(RuntimeError):
  21.     pass
  22.  
  23.  
  24. class SGMLParser(markupbase.ParserBase):
  25.     
  26.     def __init__(self, verbose = 0):
  27.         self.verbose = verbose
  28.         self.reset()
  29.  
  30.     
  31.     def reset(self):
  32.         self._SGMLParser__starttag_text = None
  33.         self.rawdata = ''
  34.         self.stack = []
  35.         self.lasttag = '???'
  36.         self.nomoretags = 0
  37.         self.literal = 0
  38.         markupbase.ParserBase.reset(self)
  39.  
  40.     
  41.     def setnomoretags(self):
  42.         self.nomoretags = self.literal = 1
  43.  
  44.     
  45.     def setliteral(self, *args):
  46.         self.literal = 1
  47.  
  48.     
  49.     def feed(self, data):
  50.         self.rawdata = self.rawdata + data
  51.         self.goahead(0)
  52.  
  53.     
  54.     def close(self):
  55.         self.goahead(1)
  56.  
  57.     
  58.     def error(self, message):
  59.         raise SGMLParseError(message)
  60.  
  61.     
  62.     def goahead(self, end):
  63.         rawdata = self.rawdata
  64.         i = 0
  65.         n = len(rawdata)
  66.         while i < n:
  67.             if self.nomoretags:
  68.                 self.handle_data(rawdata[i:n])
  69.                 i = n
  70.                 break
  71.             
  72.             match = interesting.search(rawdata, i)
  73.             if match:
  74.                 j = match.start()
  75.             else:
  76.                 j = n
  77.             if i < j:
  78.                 self.handle_data(rawdata[i:j])
  79.             
  80.             i = j
  81.             if i == n:
  82.                 break
  83.             
  84.             if rawdata[i] == '<':
  85.                 if starttagopen.match(rawdata, i):
  86.                     if self.literal:
  87.                         self.handle_data(rawdata[i])
  88.                         i = i + 1
  89.                         continue
  90.                     
  91.                     k = self.parse_starttag(i)
  92.                     if k < 0:
  93.                         break
  94.                     
  95.                     i = k
  96.                     continue
  97.                 
  98.                 if rawdata.startswith('</', i):
  99.                     k = self.parse_endtag(i)
  100.                     if k < 0:
  101.                         break
  102.                     
  103.                     i = k
  104.                     self.literal = 0
  105.                     continue
  106.                 
  107.                 if self.literal:
  108.                     if n > i + 1:
  109.                         self.handle_data('<')
  110.                         i = i + 1
  111.                         continue
  112.                     break
  113.                     continue
  114.                 
  115.                 if rawdata.startswith('<!--', i):
  116.                     k = self.parse_comment(i)
  117.                     if k < 0:
  118.                         break
  119.                     
  120.                     i = k
  121.                     continue
  122.                 
  123.                 if rawdata.startswith('<?', i):
  124.                     k = self.parse_pi(i)
  125.                     if k < 0:
  126.                         break
  127.                     
  128.                     i = i + k
  129.                     continue
  130.                 
  131.                 if rawdata.startswith('<!', i):
  132.                     k = self.parse_declaration(i)
  133.                     if k < 0:
  134.                         break
  135.                     
  136.                     i = k
  137.                     continue
  138.                 
  139.             elif rawdata[i] == '&':
  140.                 if self.literal:
  141.                     self.handle_data(rawdata[i])
  142.                     i = i + 1
  143.                     continue
  144.                 
  145.                 match = charref.match(rawdata, i)
  146.                 if match:
  147.                     name = match.group(1)
  148.                     self.handle_charref(name)
  149.                     i = match.end(0)
  150.                     if rawdata[i - 1] != ';':
  151.                         i = i - 1
  152.                         continue
  153.                     continue
  154.                 
  155.                 match = entityref.match(rawdata, i)
  156.                 if match:
  157.                     name = match.group(1)
  158.                     self.handle_entityref(name)
  159.                     i = match.end(0)
  160.                     if rawdata[i - 1] != ';':
  161.                         i = i - 1
  162.                         continue
  163.                     continue
  164.                 
  165.             else:
  166.                 self.error('neither < nor & ??')
  167.             match = incomplete.match(rawdata, i)
  168.             if not match:
  169.                 self.handle_data(rawdata[i])
  170.                 i = i + 1
  171.                 continue
  172.             
  173.             j = match.end(0)
  174.             if j == n:
  175.                 break
  176.             
  177.             self.handle_data(rawdata[i:j])
  178.             i = j
  179.         if end and i < n:
  180.             self.handle_data(rawdata[i:n])
  181.             i = n
  182.         
  183.         self.rawdata = rawdata[i:]
  184.  
  185.     _decl_otherchars = '='
  186.     
  187.     def parse_pi(self, i):
  188.         rawdata = self.rawdata
  189.         if rawdata[i:i + 2] != '<?':
  190.             self.error('unexpected call to parse_pi()')
  191.         
  192.         match = piclose.search(rawdata, i + 2)
  193.         if not match:
  194.             return -1
  195.         
  196.         j = match.start(0)
  197.         self.handle_pi(rawdata[i + 2:j])
  198.         j = match.end(0)
  199.         return j - i
  200.  
  201.     
  202.     def get_starttag_text(self):
  203.         return self._SGMLParser__starttag_text
  204.  
  205.     
  206.     def parse_starttag(self, i):
  207.         self._SGMLParser__starttag_text = None
  208.         start_pos = i
  209.         rawdata = self.rawdata
  210.         if shorttagopen.match(rawdata, i):
  211.             match = shorttag.match(rawdata, i)
  212.             if not match:
  213.                 return -1
  214.             
  215.             (tag, data) = match.group(1, 2)
  216.             self._SGMLParser__starttag_text = '<%s/' % tag
  217.             tag = tag.lower()
  218.             k = match.end(0)
  219.             self.finish_shorttag(tag, data)
  220.             self._SGMLParser__starttag_text = rawdata[start_pos:match.end(1) + 1]
  221.             return k
  222.         
  223.         match = endbracket.search(rawdata, i + 1)
  224.         if not match:
  225.             return -1
  226.         
  227.         j = match.start(0)
  228.         attrs = []
  229.         if rawdata[i:i + 2] == '<>':
  230.             k = j
  231.             tag = self.lasttag
  232.         else:
  233.             match = tagfind.match(rawdata, i + 1)
  234.             if not match:
  235.                 self.error('unexpected call to parse_starttag')
  236.             
  237.             k = match.end(0)
  238.             tag = rawdata[i + 1:k].lower()
  239.             self.lasttag = tag
  240.         while k < j:
  241.             match = attrfind.match(rawdata, k)
  242.             if not match:
  243.                 break
  244.             
  245.             (attrname, rest, attrvalue) = match.group(1, 2, 3)
  246.             if not rest:
  247.                 attrvalue = attrname
  248.             elif "'" == "'":
  249.                 pass
  250.             elif not "'" == attrvalue[-1:]:
  251.                 if '"' == '"':
  252.                     pass
  253.                 elif '"' == attrvalue[-1:]:
  254.                     attrvalue = attrvalue[1:-1]
  255.                 
  256.             attrs.append((attrname.lower(), attrvalue))
  257.             k = match.end(0)
  258.             continue
  259.             attrvalue[:1]
  260.         if rawdata[j] == '>':
  261.             j = j + 1
  262.         
  263.         self._SGMLParser__starttag_text = rawdata[start_pos:j]
  264.         self.finish_starttag(tag, attrs)
  265.         return j
  266.  
  267.     
  268.     def parse_endtag(self, i):
  269.         rawdata = self.rawdata
  270.         match = endbracket.search(rawdata, i + 1)
  271.         if not match:
  272.             return -1
  273.         
  274.         j = match.start(0)
  275.         tag = rawdata[i + 2:j].strip().lower()
  276.         if rawdata[j] == '>':
  277.             j = j + 1
  278.         
  279.         self.finish_endtag(tag)
  280.         return j
  281.  
  282.     
  283.     def finish_shorttag(self, tag, data):
  284.         self.finish_starttag(tag, [])
  285.         self.handle_data(data)
  286.         self.finish_endtag(tag)
  287.  
  288.     
  289.     def finish_starttag(self, tag, attrs):
  290.         
  291.         try:
  292.             method = getattr(self, 'start_' + tag)
  293.         except AttributeError:
  294.             
  295.             try:
  296.                 method = getattr(self, 'do_' + tag)
  297.             except AttributeError:
  298.                 self.unknown_starttag(tag, attrs)
  299.                 return -1
  300.  
  301.             self.handle_starttag(tag, method, attrs)
  302.             return 0
  303.  
  304.         self.stack.append(tag)
  305.         self.handle_starttag(tag, method, attrs)
  306.         return 1
  307.  
  308.     
  309.     def finish_endtag(self, tag):
  310.         if not tag:
  311.             found = len(self.stack) - 1
  312.             if found < 0:
  313.                 self.unknown_endtag(tag)
  314.                 return None
  315.             
  316.         elif tag not in self.stack:
  317.             
  318.             try:
  319.                 method = getattr(self, 'end_' + tag)
  320.             except AttributeError:
  321.                 self.unknown_endtag(tag)
  322.  
  323.             self.report_unbalanced(tag)
  324.             return None
  325.         
  326.         found = len(self.stack)
  327.         for i in range(found):
  328.             if self.stack[i] == tag:
  329.                 found = i
  330.                 continue
  331.         
  332.         while len(self.stack) > found:
  333.             tag = self.stack[-1]
  334.             
  335.             try:
  336.                 method = getattr(self, 'end_' + tag)
  337.             except AttributeError:
  338.                 method = None
  339.  
  340.             if method:
  341.                 self.handle_endtag(tag, method)
  342.             else:
  343.                 self.unknown_endtag(tag)
  344.             del self.stack[-1]
  345.  
  346.     
  347.     def handle_starttag(self, tag, method, attrs):
  348.         method(attrs)
  349.  
  350.     
  351.     def handle_endtag(self, tag, method):
  352.         method()
  353.  
  354.     
  355.     def report_unbalanced(self, tag):
  356.         if self.verbose:
  357.             print '*** Unbalanced </' + tag + '>'
  358.             print '*** Stack:', self.stack
  359.         
  360.  
  361.     
  362.     def handle_charref(self, name):
  363.         
  364.         try:
  365.             n = int(name)
  366.         except ValueError:
  367.             self.unknown_charref(name)
  368.             return None
  369.  
  370.         if not None if n <= n else n <= 255:
  371.             self.unknown_charref(name)
  372.             return None
  373.         
  374.         self.handle_data(chr(n))
  375.  
  376.     entitydefs = {
  377.         'lt': '<',
  378.         'gt': '>',
  379.         'amp': '&',
  380.         'quot': '"',
  381.         'apos': "'" }
  382.     
  383.     def handle_entityref(self, name):
  384.         table = self.entitydefs
  385.         if name in table:
  386.             self.handle_data(table[name])
  387.         else:
  388.             self.unknown_entityref(name)
  389.             return None
  390.  
  391.     
  392.     def handle_data(self, data):
  393.         pass
  394.  
  395.     
  396.     def handle_comment(self, data):
  397.         pass
  398.  
  399.     
  400.     def handle_decl(self, decl):
  401.         pass
  402.  
  403.     
  404.     def handle_pi(self, data):
  405.         pass
  406.  
  407.     
  408.     def unknown_starttag(self, tag, attrs):
  409.         pass
  410.  
  411.     
  412.     def unknown_endtag(self, tag):
  413.         pass
  414.  
  415.     
  416.     def unknown_charref(self, ref):
  417.         pass
  418.  
  419.     
  420.     def unknown_entityref(self, ref):
  421.         pass
  422.  
  423.  
  424.  
  425. class TestSGMLParser(SGMLParser):
  426.     
  427.     def __init__(self, verbose = 0):
  428.         self.testdata = ''
  429.         SGMLParser.__init__(self, verbose)
  430.  
  431.     
  432.     def handle_data(self, data):
  433.         self.testdata = self.testdata + data
  434.         if len(`self.testdata`) >= 70:
  435.             self.flush()
  436.         
  437.  
  438.     
  439.     def flush(self):
  440.         data = self.testdata
  441.         if data:
  442.             self.testdata = ''
  443.             print 'data:', `data`
  444.         
  445.  
  446.     
  447.     def handle_comment(self, data):
  448.         self.flush()
  449.         r = `data`
  450.         if len(r) > 68:
  451.             r = r[:32] + '...' + r[-32:]
  452.         
  453.         print 'comment:', r
  454.  
  455.     
  456.     def unknown_starttag(self, tag, attrs):
  457.         self.flush()
  458.         if not attrs:
  459.             print 'start tag: <' + tag + '>'
  460.         else:
  461.             print 'start tag: <' + tag,
  462.             for name, value in attrs:
  463.                 print name + '=' + '"' + value + '"',
  464.             
  465.             print '>'
  466.  
  467.     
  468.     def unknown_endtag(self, tag):
  469.         self.flush()
  470.         print 'end tag: </' + tag + '>'
  471.  
  472.     
  473.     def unknown_entityref(self, ref):
  474.         self.flush()
  475.         print '*** unknown entity ref: &' + ref + ';'
  476.  
  477.     
  478.     def unknown_charref(self, ref):
  479.         self.flush()
  480.         print '*** unknown char ref: &#' + ref + ';'
  481.  
  482.     
  483.     def unknown_decl(self, data):
  484.         self.flush()
  485.         print '*** unknown decl: [' + data + ']'
  486.  
  487.     
  488.     def close(self):
  489.         SGMLParser.close(self)
  490.         self.flush()
  491.  
  492.  
  493.  
  494. def test(args = None):
  495.     import sys
  496.     if args is None:
  497.         args = sys.argv[1:]
  498.     
  499.     if args and args[0] == '-s':
  500.         args = args[1:]
  501.         klass = SGMLParser
  502.     else:
  503.         klass = TestSGMLParser
  504.     if args:
  505.         file = args[0]
  506.     else:
  507.         file = 'test.html'
  508.     if file == '-':
  509.         f = sys.stdin
  510.     else:
  511.         
  512.         try:
  513.             f = open(file, 'r')
  514.         except IOError:
  515.             msg = None
  516.             print file, ':', msg
  517.             sys.exit(1)
  518.  
  519.     data = f.read()
  520.     if f is not sys.stdin:
  521.         f.close()
  522.     
  523.     x = klass()
  524.     for c in data:
  525.         x.feed(c)
  526.     
  527.     x.close()
  528.  
  529. if __name__ == '__main__':
  530.     test()
  531.  
  532.